Chip 1996 April

home *** CD-ROM | disk | FTP | other *** search

/ Chip 1996 April / CHIP 1996 aprilis (CD06).zip / CHIP_CD06.ISO / hypertxt.arj / 92 / PASCAL.CD < prev next >

Wrap

Text File | 1995-09-17 | 31KB | 629 lines

@VRohaaam!!!...@N @VStony Brook Pascal+@N A Stony Brook cég Pascal+-a fejlesztôi környezetként ugyan nem váltja fel a Turbo Pascalt, de gyorsabb és tömörebb programokat állít elô. Amikor új szoftvertermékek jelennek meg a piacon, a gyártók azonnal nagydobra verik a hírét. Ez a Stony Brook cég új Pascal+ compilerére is igaz, szeretnék vele megelôzni a népszerû Turbo Pascal 6.0-t. A CHIP alaposan letesztelte a Pascal+ legújabb, 6.0e verzióját, és összehasonlította a Turbo Pascal 6.0-val. Beszámolunk mindkét szoftvertermék összes elônyérôl és hátrányáról. A gyártó adatai szerint a Pascal+ százszázalékig forrás-kompatibilis a Turbo Pascal 6.0-val. Ez azt jelenti, hogy minden olyan Pascal programot, amit megemészt a Turbo Pascal, a Pascal+ is fel tud dolgozni anélkül, hogy a programozónak a forrásszöveg egyetlen sorát meg kellene változtatnia. A Stony Brook cég továbbá azt állítja, hogy a Pascal+ által elôállított kód kétszer gyorsabb, és 30 százalékkal tömörebb mint a Turbóé. A Pascal+ csomagja három vaskos angol kézikönyvbôl és három floppyból áll, amelyeken tömörítve rajta van az összes program. Mindent egybevéve a szoftver kilenc részbôl áll, ezek: a fejlesztôi környezet, a Pascal compiler, a debugger, a futásidejû könyvtár, a make segédprogram, a linker, az objektumkezelô, a definíciós modulok a Windows úgynevezett Application Program Interface-éhez (API) és a Windows-programozáshoz szükséges könyvtár. A Pascal+ tehát optimálisan felhasználható DOS-szinten és Windows-ban való programozáshoz is. @VNincs probléma a Windowszal@N A lemezeken rajta van a Technojock Object Toolkit és a TEGL Windows-Toolkit is. A Pascal+ felhasználója mindkét segédeszközzel kényelmesen programozhat saját ablakkezelôt, amely azonban egyáltalán nem hasonlít a Windowshoz. Az ingyenesen mellékelt toolkitekkel olyan, egyszerûbb ablakok hozhatók létre, amilyeneket a Turbo Pascal 6.0-ból ismerhetünk. A Windows alatt futtatni kívánt Pascal programokat a Stony Brook programcsomagjában szintén meglévô PPC compilerrel kell lefordítani. Ezt a compilert speciálisan a Windows-programozáshoz fejlesztették ki. Ezenkívül minden olyan Windows-környezetbe szánt modult meg kell jelölni a @K//WINDOWS@N fordítási elôírással. Ez az opció arra ösztönzi a Pascal+-t, hogy az eljárások meghívásakor és a belôlük való kilépéskor egy olyan speciális utasítássorozatot állítson elô, amely gondoskodik arról, hogy a Windows 3.0 vagy 3.1 képes legyen együttmûködni a lefordított Pascal programmal. A Microsoft resource compilere (RC), amely a Windows SDK része, igen jól illeszkedik a Pascal+-hoz. Nézzük a két toolkitet: a TechnoJock programkönyvtár nagy segítséget jelent az egyre divatosabb objektumorientált programozásban. A saját programokba könnyen beépíthetünk vele párbeszéddobozokat és modern ablaktechnikát. A TEGL ezzel szemben sok grafikai rutint és olyan programokat tartalmaz, amelyek virtuális tárkezelést és saját ablakkezelést tesznek lehetôvé. Ehhez jön még egy további csemege: a Pascal+ compiler teljes futásidejû könyvtárának forrásszövege nemsokára kapható lesz mintegy 350 márkáért a grencheni (Svájc) A+L cégnél. îgy a programozók kezében lesz az összes olyan eszköz, amellyel el tudnak bánni a legmakacsabb hibákkal is. Aki kizárólag a Turbo Pascallal dolgozik, az kevéssé törôdik a Turbo compiler által elôállított object file-okkal. Közismert, hogy az object file-ok olyan gépi kódot tartalmaznak, amelybôl a linker állítja elô a végleges, futtatható programot, .EXE file formájában. Akinek hivatásából adódóan több programnyelvvel van dolga, és naponta szeretne egymással összekapcsolni Pascal, C, assembly és más nyelven írt object file-okat, az, ha Turbo Pascal-t használ, nagy problémákba ütközik. A Turbo 6.0 ugyanis speciális object file-okat készít, amelyek nem kompatibilisek a DOS területérôl származó más fordítóprogramokéval. A Pascal+ ezzel szemben olyan object file-okat készít, amelyek minden szempontból eleget tesznek a szokásos Microsoft-szabványnak. Míg a Turbo Pascal felhasználója elszigetelt programozási környezetben él, addig a Stony Brook cég Pascal+ compilerével a programozók elôtt tárva-nyitva áll szinte az összes professzionális programozói platform. @V10..30 százalékkal tömörebb kód@N Az esetlegesen elôforduló kompatibilitási problémák vizsgálatára elôvettük több nagyobb Pascal program forrásszövegét -- e programokat a szerkesztôségben fejlesztették ki az ávek során. Ezek közül az elsô az ismert @K(Németországban nagyon @Kolcsón, nagy mennyiségben eladott)@N TDB-4 Turbo-adatbáziskezelô program, amit Pascalban és assemblyben írtak, és amely kihasználja a Turbo Pascal 6.0 compiler sok jellegzetes tulajdonságát. Az adatbáziskezelô legtöbb, gyors futást kívánó részét assemblyben írták, mivel a Turbo compiler által elôállított kód e helyeken egyszerûen túl lassú volt. A TDB-4 adatbáziskezelô program forrásszövege több mint 20 ezer sorból áll, és a merevlemezen bô 700 Kbyte-ot foglal el. Bár sok benne az olyan programrész, amely sajátosan a Turbora jellemzô, a Pascal+ zúgolódás nélkül lefordította a forrásszöveget. A Turbo Pascal 6.0 a TDB-4 forráskódjából 310 Kbyte-os .EXE file-t állított elô. A Pascal+-szal az .EXE file 283 Kbyte-ra zsugorodott össze. A megtakarítás mintegy tíz százalék. A Stony Brook ugyan azt állítja, hogy a Pascal+ kódja akár 30 százalékkal is rövidebb mint a Turbo Pascal 6.0-é, de a TDB-4 esetében ez nem volt igaz. Ennek ellenére érdemes volt a Pascal+-szal lefordítani a TDB-4-et, hiszen 30 Kbyte-tal több memória marad a heap számára, amely az a memóriaterület, ahol a TDB-4 futás közben az összes elôforduló adatot kezeli. îgy a TDB-4 nem ütközik olyan hamar a DOS 640 Kbyte-os korlátjába. A második program egy szabványos Pascal compiler forráskódja volt. Egy P-kódra fordító compilerrôl van szó, amelyhez írtak egy P-kód-assemblert és Pascalban egy P-kód-interpretert is. A P-kód-compiler képes önmagát lefordítani és lefuttatni (bootstrap compiler). A körülbelül 9000 programsorból álló forráskód tervezése során különleges figyelmet fordítottunk az áttekinthetôségre és egyszerû olvashatóságra. Tudatosan nem használtunk olyan megoldásokat, amelyek ugyan hatékony gépi kódhoz vezetnének, de nehezebbé tennék a program megértését. A P-kód-compiler forráskódját elôször Turbo 6.0-val fordítottuk le. A létrehozott .EXE file hossza 94|598 byte volt. òriási meglepetés ért minket, amikor a Pascal+ 66|169 byte-ot produkált -- ez 30 százalékkal tömörebb kód, mint a Turbo Pascal-é. Ez az érték összhangban van a Stony Brook reklámjával. @VDupla sebesség@N Harmadik programként egy CAD-program forrásszövegét jelöltük ki, amit nagyobb repülôgép-modellek kifejlesztésére írt egy programozó. Körülbelül 2000 soros, jól kihasználja a számítógép VGA-kártyáját, és az Intel 80287-es koprocesszorával futtatható. Az aritmetikai processzorra óriási szükség van, mivel a CAD-programnak több differenciálegyenlet-rendszert kell megoldania, mielôtt megszerkeszthetné a képernyôn lévô grafikát. A Pascal+-szal való lefordítás után ennek a programnak az .EXE file-ja is 32 százalékkal rövidebb volt mint a Turbo Pascal compileré. A grafikus megjelenítés sebessége pedig átlagosan 2,2-szer gyorsabban történt mint a Turbo 6.0-val. Ha a debuggerrel szemléljük meg a Pascal+ által elôállított gépi kódot, akkor világossá válik, hogy miért megy végbe gyorsabban a grafikus megjelenítés: a Turbo Pascal a paramétereket a verembôl veszi elô, ami sok idôt vesz igénybe, a Pascal+ közvetlenül a CPU regisztereibôl írja át azokat a videomemóriába. A maximálisan optimalizált kód tehát a grafikus megjelenítés során is elônyöket nyújt. Egy mátrixösszeadás alapján világossá válhat, hogy a Turbo Pascal 6.0-hoz képest a Pascal+ mennyivel tömörebb kódot készít. Azért, hogy a Pascal program a lehetô legegyszerûbb maradjon, a mátrix elemeit nem inicializáltuk, és nem írattuk ki. Még egy olyan rövid programnál is, mint a mátrixösszeadás, a Pascal+ egyharmadával csökkentette a gépi kódot. @VAz assembly alig ad elônyt@N Sok Turbo Pascalt használó fejlesztô a gyors futást igénylô programrészek írásakor áttér az assemblyben való programozásra, mivel a compiler által elôállított gépi kód nem elég gyors. A Pascal+ használatakor gyakran nincs már szükség az idôigényes és sok hibalehetôséget magában rejtô assembly programozásra, mivel a compiler által készített kód is elég gyors. A halmazok és a halmazokkal való mûveletek egyike azoknak az értékes lehetôségeknek, amelyekkel rendelkezik a Pascal. A programozói munka halmazok használatakor sok esetben leegyszerûsödik, és javul a programok olvashatósága. Sok programozó éppen a halmazoknál látja a Turbo Pascal egyik kritikus pontját: ha gyors és hatékony kód kell, sok Turbo Pascalt használó programozó más programszerkezeteket vagy az assemblyt választja. Ha tehát a dolog a sebességen múlik, akkor például az @KIF ch IN ['A'..'Z','a'..'z'] THEN...@N halmaz-mûveletet így írnánk Turbo Pascalban: @KIF (ch>='A') AND (ch<='Z') @KOR @K(ch>='a') AND (ch<='z') @KTHEN...@N A Pascal+ esetében azonban nincs jelentôsége annak, hogy az elsô vagy a második programszerkezetet használjuk-e, mivel a compiler mindkettôbôl ugyanazt a hatékony kódot állítja elô. A Pascal+ compiler fejlesztôi igen jól oldották meg a hozzáférést a már meglévô, C nyelven írt programkönyvtárakhoz. Csak egy Pascal unitot kell írni, amelynek interface részében fel van sorolva a C könyvtár összes eljárása. E unit implementációs része üres. Tegyük fel, hogy az egyik C könyvtárban igen gyors grafikai rutinok találhatók, amiket bele kell illeszteni egy Pascal programba. A CGraph unit ekkor például így nézhet ki Pascal+-ban: @KUnit CGraph; @KINTERFACE @KPROCEDURE @KDrawLine (x1,y1,x2,y2:integer); @K[C]; external '_DrawLine'; @K.... @KIMPLEMENTATION @KEND.@N A ""[C]" karakterlánc olyan eljárás-attribútum, amely egy C függvényt jelez. A '_DrawLine' jelölés egy nyilvános nevet (PUBLIC) jelöl a C könyvtárban. A ""[C]" attribútumon kívül a Pascal+ még további kilencet ismer. A Pascal+ programozónak így állandóan rendelkezésére áll egy roppant nagy szoftverbázis. Mivel nem kell mindig újra feltalálni a kereket, ezért a Pascal+-szal igen hatékonyan lehet dolgozni: ha a megfelelô rutin nem található meg egyik C könyvtárban sem, akkor a fejlesztô például átkutat egy Fortran könyvtárat, és megtalálja, amit keresett. A Pascal+ jelmondata tehát az, hogy több lovat kell egyszerre megülni. Mindenesetre az esetleges problémák elkerülése végett az ""idegen nyelvû" compiler a Microsoft terméke legyen. Megdöbbentôen tömör és gyors kódot állít elô a Pascal+ compiler. Ezért megvizsgáltuk, hogyan dolgozik a compiler a kódgeneráláskor. Ennek során figyelemre méltó technikák kerültek napvilágra, amelyek szinte minden lehetôséget kimerítenek. @VCsak a kód optimalizálása növeli a sebességet@N A kód optimálásában használt jelszavak: adatfolyam-analízis és kulcslyuk- (peephole-) optimalizálás. Néhány példával megvilágítjuk, mit kell ezek alatt érteni. Amikor a Pascal+ lefordít egy programot, a compiler nemcsak a forrásszöveget vizsgálja meg, hanem megjegyzi a Pascal programban lévô összes változót és más objektumot is. Tegyük fel, hogy egy rossz programozó a program futása alatt csak egyetlen egyszer ad valamilyen értéket az egyik változónak. Ekkor a Pascal+ a változót a kódban konstanssal helyettesíti. Egy konstans címzése gyorsabb, és alig igényel gépi kódot. A következô példa ugyanezt az irányt követi, és a kódoptimalizáló mûködési módját szemlélteti a kód elôállítása során: @KVAR a,b: integer; @K.... @Ka: = 1; b: = 1; @K.... @Kb: = a; @K....@N A Pascal+ itt kitalálja az adatfolyam-analízis segítségével, hogy a program futása alatt az ""a" és a ""b" változók értéke ugyanaz. Ezért a @Kb: = a@N értékadás felesleges. A Pascal+ compiler így kihagyja az értékadás kódját. Adott a következô programszerkezet: @KIF (a+b)<>0 @KTHEN @Ky: = x DIV (a+b) @KELSE @K.....@N Itt a feltételben és az értékadásban is elôfordul az @K(a+b)@N kifejezés. Az adatfolyam-analízis segítségével a Pascal+ megjegyzi a kiszámított @K(a+b)@N kifejezést, és, ha lehetséges, konstanssá redukálja. Más szavakkal: az @K(a+b)@N kifejezés értéke a program futása alatt vagy egy CPU-regiszteren keresztül vagy a veremben lévô konstansként kerül átadásra. Ez az optimalizálás gépi kódot takarít meg és növeli a sebességet. Egy másik optimálási technika az, hogy a Pascal+ automatikusan csökkenti az aritmetikai kifejezéseket és a változók hosszát. Például egy @Kinteger@N szám kettô-hatvánnyal való osztását gyors eltolási és forgatási mûveletekkel helyettesíti. Ha egy @Kinteger@N változó (16 bit) értéke a program futása alatt a paraméter átadásánál belefér egyetlen byte-ba (8 bit), akkor csak egyetlen byte kerül átadásra. Szorzásnál és osztásnál egyébként a Turbo Pascal is hasonló optimálásokat végez. A programok áttekinthetôsége érdekében a Pascalban fejlesztôk gyakran írnak sok kis eljárást, amelyek a program futása alatt csak egyszer-kétszer kerülnek meghívásra. Az eljáráshívások elég idôigényesek, mivel a veremben memóriát kell lefoglalni, különbözô paramétereket, az eljárás saját adatait és a visszatérési címet el kell helyezni a veremben, mielôtt megkezdôdhet a tulajdonképpeni munka. Az eljárásból való visszatéréskor pedig ki kell takarítani a vermet. Az adatfolyam-analízis segítségével a Pascal+ itt is optimál. Megjegyzi, hol és hányszor hívják meg az eljárást. Ha lehet, az eljárásokat kifejti, és spagetti-kódként építi be a programba. Ugyanezt csinálja a rövidebb ciklusokkal, amelyek csak egyszer-kétszer hajtódnak végre. A peephole-optimálást leegyszerûsítve így lehet leírni: amikor a compiler egyszer már elôállította a kódot egy programrészlet számára, akkor az optimáló még egyszer átvizsgálja a kész kódot, és eldönti, hogy nem lehet-e egyik vagy másik részt leegyszerûsíteni. Ha egy több, egymást követô lépésbôl álló mintát megtalál egy táblázatban, akkor azokat a táblázatban megadott egyszerûbb lépéssorral helyettesíti. Anders Hejlsberg, a Turbo Pascal compiler feltalálója és írója néhány éve, egy CHIP-nek adott interjú után nyilatkozott programjának végsô finomításával kapcsolatban: nem ô maga gyomlálta ki a compiler utolsó hibáit, hanem az a sok programozó, akik a Turbo Pascallal dolgoztak -- ez hívta fel a figyelmét arra, hogy az ördög a részletekben lakozik. Mivel a Pascal+ még egészen új a piacon, a CHIP kíváncsi volt arra, hogy vajon nem maradt-e benne valamilyen programozási hiba. E keresés erôsen hasonlított a jól ismert ""tû a szénakazalban" esetre. Hiszen kitûnô programozók adták bele legjobb tudásukat ebbe a compilerbe, amely meg akarja elôzni a Turbo Pascalt. Teljesen különbözô felhasználási területekrôl származó, további programokat fordítottunk le a Stony Brook Pascal+-szal, és lefuttattuk azokat. Itt is a részletekben lakozott az ördög: a Pascal+ CHIP-tesztverziójában találtunk néhány hibát. E hibákat az itt kinyomtatott tesztprogrammal fedeztük fel. A hibákat jeleztük az amerikai Stony Brook cég szoftverfejlesztôinek. Elôször néhány szó a tesztprogramról: a Turbo Pascal a Write() eljárásban lehetôvé teszi a paraméterek formázott kiírását. Ennek során az érintett adatok balra és jobbra zárva is megjeleníthetôk. A @KWriteln ('hallo': - 20)@N utasítás azt jelenti, hogy a @K'hallo'@N karakterláncnak bal oldalon kell megjelennie egy 20 karakter hosszú mezôben. Ez nem probléma a Turbo Pascal számára. A Pascal+ viszont rosszul értelmezte az utasításban lévô mínuszjelet, és 65535-20, azaz 65515 üres sort írt le, mielôtt végül megjelent a @K'hallo'@N karakterlánc. A második hiba a FSPLIT eljárásban rejtôzött. A futásidejû könyvtár e rutinja szétbont egy karakterláncot file-névre és file-névkiterjesztésre. Amíg a FSPLIT-nek megadott karakterlánc szintaxisa megfelelô volt, addig a Pascal+-nak nem volt problémája. Azonban szintaktikailag hibás karakterláncot vagy a karakterláncon belül üres sztringet nem tudott feldolgozni a Pascal+-compiler FSPLIT eljárása. Ahelyett, hogy közölte volna a hibát, vagy megállt volna, a program grafikus karaktereket írt a képernyôre. A harmadik szépséghiba a VAL eljárásban rejtôzött, amely tudvalevôleg egy numerikus karakterláncot értékké alakít át. Nincs jelentôsége annak, hogy a karakterlánc egész (integer) vagy tört (real) számot képvisel. A VAL csak akkor mûködött, ha az átadott argumentum korrekt volt. A Pascal+-szal ellentétben hibás argumentum esetén a Turbo Pascal jelezte a nem odavaló karakter helyét a karakterláncban. A képernyô kinyomtatott képe mutatja, hogy a Pascal+ mit kezdett a hibás számsorral. A negyedik hiba az úgynevezett hibakezelôben, a futásidejû könyvtár egyik eljárásában bukkant elô, amely akkor kerül meghívásra, ha a felhasználói program futása alatt hiba keletkezik. Ilyenkor a Pascal+ korrekt módon megszakította a programot, de nem adta meg pontosan a hiba sorszámát és a hiba címét. Mint a faxmásolat mutatja, a Stony Brook szoftvercsoportja 24 órán belül kiküszöbölte a CHIP által felfedezett összes hibát. A Pascal+ forgalmazója, a svájci A+L AG biztosított minket továbbá arról, hogy legkésôbb egy hónapon belül ki lesznek gyomlálva a CHIP által felfedezett, hálózati üzemelés során jelentkezô problémák. Még a Windows 3.1 verziójának tesztprogramjaival sem találtunk további hibákat a compilerben. Egyetlen sort sem kell megváltoztatni a Turbo Pascal programok forrásszövegében -- reklámozza a Stony Brook cég hirdetési kampányában. Ez addig igaz, amíg nem dolgozunk overlay-kkel. Az overlay-k használata olyan programozási módszer, amelynek során különbözô programrészek foglalják el ugyanazt a memóriaterületet. Az ""átfedô" programrészek gépi kódja mindaddig a merevlemezen marad, amíg nem kerül felhasználásra. Mihelyt egy adott programszakaszra szükség van, betöltôdik a helyére. A Stony Brook nem vette át a Turbo Pascal overlay-technikáit, mivel azok túl sok korlátozással terhelik meg az egyre inkább divatba jövô Windows-programokat. A Turbo Pascal által az overlay-zés során használt memóriakiosztási technikák sem tetszettek a Pascal+ fejlesztôinek. Ezért az overlay-knél tudatosan mondtak le a Turbo Pascallal való kompatibilitásról. A Stony Brook azért sem vette át a Borlandtól az overlay-technikát, mert a Turbo Pascalban az overlay-k felosztása a unitoknak felel meg. Emiatt különösen akkor vész kárba sok idô a betöltéssel és kimentéssel, amikor az egyik overlay hívja a másikat. A Pascal+-ban az overlay-k különálló eljárásokból, unitokból vagy a kettô kombinációjából állhatnak. A programozó továbbá hozzárendelhet egy meghatározott eljárást vagy unitot egy overlay-hez, ezenkívül pedig minden overlay-hez meghatározott memóriaterületet. Ha tehát két különbözô overlay-bôl származó, két eljárás kölcsönösen meghívja egymást, akkor mindkét eljárás egyidejûleg bent lehet (többnyire bent is van) a memóriában. A program így sokkal gyorsabban fut. Tehát azoknak a programozóknak, akik a forrásszövegben lévô Turbo Pascal stílusú overlay-ket a Pascal+-szal szeretnék lefordítani, kisebb változtatásokat kell saját kezûleg elvégezniük. A Pascal+ egyik kézikönyvében tíz odalon keresztül pontosan le vannak írva az overlay-k részletei és programozási módozataik: @KAREA @KOverlay Prog1; @KOverlay Prog2; @K.............. @KOverlay Progn;@N Az AREA parancs annak a memóriaterületnek a kezdetét definiálja, amely késôbb magában foglalja a mindenkori overlay kódját. Az AREA-t követô összes overlay-utasítás használhatja ezt az összefüggô memóriaterületet. Az overlay-khez hozzárendelt terület automatikusan akkora lesz, hogy több overlay együttesen is beleférjen, ha az egyik overlay egy másikat hív meg. Akinek a Turbo Pascal mellé még szüksége van egy rendes, szimbolikus hibakeresôre, annak külön kell megvennie a Turbo Debuggert. A Pascal+ csomag már eleve tartalmazza a szimbolikus SBDEBUG hibakeresôt, amely nem annyira terjedelmes és részletes mint a Borland terméke. Az elôállított gépi kód kinyomtatott listáit a mindenkori debuggerrel készítettük el. A Borland és a Stony Brook termékei közötti különbségek világosan felismerhetôk. A Turbo Debuggerhez hasonlóan az SBDEBUG is interaktívan használható, és kijelzi mind a Pascal forráskódot, mind pedig az elkészített gépi kódot. @VBeépített szimbolikus debugger@N A Stony Brook terméke ezenfelül elôállít egy olyan debug-információt, amely kompatibilis a Microsoft Codeview debuggerével. Az SBDEBUG-ot így olyan programokon is lehet használni, amelyeket C compilerrel, a Microsoft Fortran compilerével vagy a Stony Brook saját Modula-2 compilerével fordítottak le. Eltekintve néhány korlátozástól a Turbo Debuggerhez képest, a Pascal+ debugerrel is meglehetôsen jól lehet dolgozni. Már csak az a kérdés marad, hogy a Pascal+ egyenrangú-e a jól bevált Turbo Pascal 6.0-val vagy esetleg jobb annál? A rugalmas, grafikus kezelési felülettel rendelkezô, két Pascal compilert teljesen eltérô célfeladatokra fejlesztették ki. A Turbo Pascal hatszor-tízszer gyorsabban fordítja le a forrásprogramokat mint a Pascal+. Ezzel szemben a Pascal+ maximálisan optimált kódot készít, amely a szokásos Pascal programok esetén körülbelül 30%-kal tömörebb, és kétszer gyorsabb. Ha a Pascal+ túl akarja szárnyalni a Turbo Pascalt, akkor még három fontos változtatás szükséges: elôször is a compilerbe be kell építeni egy olyan opciót, amellyel egyszerû, optimálás nélküli kód fordítása kérhetô. Ez növelné a fordítás sebességét. Csak a program végleges változatánál lenne érdemes teljes optimálást kérni. (A Stony Brook cég a Modula-2 compilerébe már beépített ilyen lehetôséget.) Másrészt a Pascal+-nak a Turbo Pascallal ellentétben sajnos nincs helyzetfigyelô súgója (help). A Pascal+ kézikönyvei nélkülözhetetlenek -- a Turbo Pascalnál a felhasználó szinte mindent, amit a kézikönyvek tartalmaznak, elôhívhat az [F1] vagy a [Ctrl F1] gombokkal. Aki jóval ezren felüli változót, konstanst és eljárást szeretne beépíteni a programjába, az aligha él meg egy olyan súgó nélkül mint a Turbo Pascalé. Harmadsorban a Pascal+ kézikönyveit kizárólag az olyan professzionális programozók számára írták, akik járatosak az összes szokásos magasszintû programozási nyelvben. A Pascalban kezdôk aligha fognak kiigazodni ezekben a kézikönyvekben. Mivel a Pascal+ a kiváló kódgenerátora miatt igen lassan fordít, a profik továbbra is a Turbo Pascalt fogják használni a programfejlesztésben. A Pascal+ viszont kiváló ""utánégetô" a Turbo számára, mivel a belôtt programokat sokkal gyorsabbá és tömörebbé fordíthatjuk le vele. A Pascal+ fejlesztôi rendszer 1000 márkába kerül a grencheni (Svájc) A+L AG-nél. Mindent összevéve éppen ideje volt már, hogy piacra kerüljön a professzionális fejlesztôk által várva-várt Stony Brook compiler, és kapható legyen a futásidejû könyvtár forráskódja. @KLoys Nachtmann@N (* Stony Brook Pascal+ tesztprogram *) (* Loys Nachtmann, Ulrich Kern *) uses dos; const GoodString = 'c:\util\sbpascal\sbe.exe'; BadString = 'c:\util\sbpascal\'; BadReal = '1.2.3456 '; BadInteger = '123ABC '; var d: dirstr; (* path *) n: namestr; (* file name*) e: extstr; (* extension*) r: real; (* real number *) i: integer; (* integer number *) ErrorPos: integer; ErrExitSave: POINTER; ErrN, ErrM: WORD; (*$F+*) PROCEDURE Hibakezeles; BEGIN ExitProc:=ErrExitSave; writeln('Hiba: ',ExitCode, ' / Cim: ',LongInt(ErrorAddr)); END; begin (************************************************************) writeln('Az [Enter] lenyomása után kis türelmet kérek'); readln; (* a balra zárt kiírás ellenôrzése *) writeln('hallo':-20); writeln('hallo'); writeln; writeln; (************************************************************) (* az FSPLIT eljárás tesztelése *) writeln(GoodString,d,n,e); writeln(d); writeln(n); writeln(e); writeln; writeln(BadString); fsplit(BadString,d,n,e); writeln(d); writeln(n); writeln(e); writeln; (************************************************************) (* a VAL eljárás tesztelése *) val(BadReal,r,ErrorPos); writeln(Badreal, ' real=',r,' ErrorPos=',ErrorPos); val(BadInteger,i,ErrorPos); writeln(BadInteger,' integer',i,' ErrorPos=',ErrorPos); (************************************************************) (* a hibakezelés tesztelése, például osztás nullával *) ErrExitSave:=ExitProc; ExitProc:=@@Hibakezeles; writeln;writeln; write('Kérem adjon be két számot (például 2 0 [Enter]): '); readln(ErrN,ErrM); ErrM := ErrN DIV ErrM; writeln(ErrM); end. @VEz a tesztprogram felszínre hozta a Pascal+ @Vfogyatékosságait@N ---------- hallo hallo c:\util\sbpascal\sbe.exe c:\util\sbpascal\ sbe .exe c:\util\sbpascal\ c:\util\sbpascal\ 1.2.3456 real= 0.0000000000E+00 ErrorPos=4 123ABC integer=0 ErrorPos=4 Kérem adjon be két számot (például 2 0 [Enter]): 2 0 Hiba: 200 / Cim: 1152 Runtime error 200 at 0000:0480. D:\SBTEST\SOURCE> @VA Turbo Pascal kifogástalanul dolgozta fel a @Vtesztprogramot, és a futás során felismerte az összes hibát@N @KNéhány kérdés a Stony Brook céghez@N @VMiért kell még egy Pascal-compiler?@N @VCHIP:@N Miért készítették el a Pascal+-t? @VStony Brook:@N Alaposan elemeztük a compilerek piacát, és megállapítottuk, hogy különösen a professzionális Pascal-programozóknak van nagy szükségük egy optimáló compilerre. Továbbá a Turbo Pascal nem elég rugalmas e felhasználói csoport számára, mivel a Turbo objectformátuma nem kompatibilis más magas szintû nyelvekkel. @VCHIP:@N Miért írták a Pascal+-t Modula-2-ben? @VStony Brook:@N Amikor belekezdtünk a Pascal+ fejlesztésébe, volt egy kiváló Modula-2 compilerünk, amit szintén a mi fejlesztôi csoportunk írt. Ez a jó fejlesztôi eszköz egészséges kiindulópontot adott az optimáló Pascal+ compiler elkészítéséhez. @VCHIP:@N Mit gondolnak Önök a Pascalról és a Modula-2-rôl? @VStony Brook:@N Közismert, hogy e két programozási nyelv Amerikában alárendelt szerepet játszik a C-hez képest. Ezzel szemben a Pascal és a Modula-2 is nagy népszerûségnek örvend Európában. A Turbo Pascal nyelvjárás és a Modula-2 két, közel egyenértékû, magas szintû nyelv. Mindkettônek megvannak a maga elônyei és hibái. De véleményünk szerint a Turbo Pascal és a Pascal+ messze felülmúlja az összes többi, piacon kapható magasszintû nyelvet. @VCHIP:@N Amerikában a C uralkodik. Miért nem írtak optimáló C- vagy akár C++-compilert? @VStony Brook:@N Szerintünk a C és a Pascal úgy viszonyul egymáshoz, mint egy dióhéj és egy kényelmes csónak: az elôbbi sokkal könnyebben felborul és elsüllyed. Ezért a C nyelvet sem nagyon kedveljük. Mégegyszer: úgy gondoljuk, hogy a Modula-2 és a Pascal minden tekintetben magasabb szinten álló nyelvek. Ez vonatkozik a napi programozásbeli hatékonyságra, a meglévô programok karbantartására és olvashatóságára. Az újonnan belépô szoftverfejlesztôk igen gyorsan bedolgozhatják magukat a bonyolult, nagy programokba.